package com.dkd.day20250718;

import java.util.*;

public class Main26 {
    public static void main(String[] args) {
        //题目描述
        //在斗地主扑克牌游戏中， 扑克牌由小到大的顺序为：3'4'5'6'7'8'9'10'J'Q'K'A'2，玩家可以出的扑克牌阵型有：单张、对子、顺子、飞机、炸弹等。
        //
        //其中顺子的出牌规则为：由至少5张由小到大连续递增的扑克牌组成，且不能包含2。
        //
        //例如：{3'4'5'6'7}、{3'4'5'6'7'8'9'10'J'Q'K'A}都是有效的顺子；而{J'Q'K'A'2}、 {2'3'4'5'6}、{3'4'5'6}、{3'4'5'6'8}等都不是顺子。
        //
        //给定一个包含13张牌的数组，如果有满足出牌规则的顺子，请输出顺子。
        //
        //如果存在多个顺子，请每行输出一个顺子，且需要按顺子的第一张牌的大小（必须从小到大）依次输出。
        //
        //如果没有满足出牌规则的顺子，请输出No。
        //
        //输入描述
        //13张任意顺序的扑克牌，每张扑克牌数字用空格隔开，每张扑克牌的数字都是合法的，并且不包括大小王：
        //
        //2 9 J 2 3 4 K A 7 9 A 5 6
        //
        //不需要考虑输入为异常字符的情况

        Scanner sc = new Scanner(System.in);
        String[] s = sc.nextLine().split(" ");
        solve(s);
    }

    //设置静态map，得到对应值排序.
    static HashMap<String,Integer> CARD_TO_NUMBER ;
    static{
        // 初始化HashMap
        CARD_TO_NUMBER = new HashMap<>();
        // 将每张扑克牌对应的面值映射到一个整数，其中2被认为是最大的牌
        CARD_TO_NUMBER.put("3", 3);
        CARD_TO_NUMBER.put("4", 4);
        CARD_TO_NUMBER.put("5", 5);
        CARD_TO_NUMBER.put("6", 6);
        CARD_TO_NUMBER.put("7", 7);
        CARD_TO_NUMBER.put("8", 8);
        CARD_TO_NUMBER.put("9", 9);
        CARD_TO_NUMBER.put("10", 10);
        CARD_TO_NUMBER.put("J", 11);
        CARD_TO_NUMBER.put("Q", 12);
        CARD_TO_NUMBER.put("K", 13);
        CARD_TO_NUMBER.put("A", 14);
        CARD_TO_NUMBER.put("2", 16);
    }

    public static void solveself(String[] s){
        //用二维数组初始化存储的数，然后计算给个牌存在的数量
        LinkedHashMap<String,Integer> map = new LinkedHashMap<>();
        map.put("3",0);
        map.put("4",0);
        map.put("5",0);
        map.put("6",0);
        map.put("7",0);
        map.put("8",0);
        map.put("9",0);
        map.put("10",0);
        map.put("J",0);
        map.put("Q",0);
        map.put("K",0);
        map.put("A",0);
        map.put("2",0);
        //找到最开始有牌的起始点
        for(String str : s){
            if(map.containsKey(str)){
                map.put(str,map.get(str)+1);
            }
        }

        List<String> sunzi = new ArrayList<>();

        StringBuilder sb = new StringBuilder();

        int number = 13;
        int index = 0;
        while(number > 0){
            //判断index是否越界，越界重置，sb判断重组
            //如果index位置为0，sb清理，index++判断是否大于5，大于5添加
            //index位置不为0,sb++，index++,number--
            //效率低,n**2
        }
    }


    public static void solve(String[] s){
        //使用静态map，判断

        //建立顺子表
        List<List<String>> list = new ArrayList<>();
        Arrays.sort(s,(a,b)->CARD_TO_NUMBER.get(a) - CARD_TO_NUMBER.get(b));
        //遍历s,是否有顺子表衔接，没有则添加入顺子表
        for(String str : s){
            boolean flag = false;
            for(List<String> list1 : list){
                if(CARD_TO_NUMBER.get(str) - CARD_TO_NUMBER.get(list1.get(list1.size()-1)) == 1){
                    flag = true;
                    list1.add(str);
                    break;
                }
            }

            if(!flag){
                list.add(new ArrayList<>(Arrays.asList(str)));
            }
        }
        //排序
        list.sort((a,b) -> CARD_TO_NUMBER.get(a.get(0))-CARD_TO_NUMBER.get(b.get(0)));
        //打印长度超过5的顺子表
        StringBuilder sb = new StringBuilder();
        List<String> answer = new ArrayList<>();
        for(List<String> list1 : list){
            if(list1.size() >= 5){
                Arrays.stream(list1.toArray(new String[0])).forEach(str -> sb.append(str).append(" "));
                answer.add(sb.toString());

                sb.setLength(0);
            }
        }

        if(answer.isEmpty()){
            System.out.println("NO");
        }else{
            for(String str : answer){
                System.out.println(str);
            }
        }
    }

}
